home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / lib_se / assignment.e < prev    next >
Text File  |  1998-12-22  |  7KB  |  285 lines
  1. --          This file is part of SmallEiffel The GNU Eiffel Compiler.
  2. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  3. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr 
  4. --                       http://www.loria.fr/SmallEiffel
  5. -- SmallEiffel is  free  software;  you can  redistribute it and/or modify it 
  6. -- under the terms of the GNU General Public License as published by the Free
  7. -- Software  Foundation;  either  version  2, or (at your option)  any  later 
  8. -- version. SmallEiffel is distributed in the hope that it will be useful,but
  9. -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. -- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License 
  11. -- for  more  details.  You  should  have  received a copy of the GNU General 
  12. -- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
  13. -- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14. -- Boston, MA 02111-1307, USA.
  15. --
  16. class ASSIGNMENT
  17.    --
  18.    -- For instruction like :
  19.    --                          foo := bar;
  20.    --                          foo := bar + 1;
  21.    --
  22.    -- 
  23.  
  24. inherit INSTRUCTION;
  25.    
  26. creation make
  27.    
  28. feature 
  29.    
  30.    left_side: EXPRESSION;
  31.    
  32.    right_side: EXPRESSION;
  33.    
  34. feature {NONE}
  35.    
  36.    current_type: TYPE;
  37.    
  38. feature
  39.  
  40.    make(ls: like left_side; rs: like right_side) is
  41.       require
  42.      ls.is_writable;
  43.      ls.start_position /= Void;
  44.      rs /= Void
  45.       do
  46.      left_side := ls;
  47.      right_side := rs;
  48.       ensure
  49.      left_side = ls;
  50.      right_side = rs
  51.       end; 
  52.    
  53. feature
  54.    
  55.    end_mark_comment: BOOLEAN is false;
  56.  
  57. feature
  58.    
  59.    is_pre_computable: BOOLEAN is 
  60.       local
  61.      call: CALL;
  62.      rf6: RUN_FEATURE_6;
  63.       do
  64.      if left_side.is_result then
  65.         if right_side.is_pre_computable then
  66.            call ?= right_side;
  67.            if call /= Void then
  68.           rf6 ?= call.run_feature;
  69.           Result := rf6 = Void;
  70.            else
  71.           Result := true;
  72.            end;
  73.         end;
  74.      end;
  75.       end;
  76.    
  77.    afd_check is
  78.       do
  79.      right_side.afd_check;
  80.       end;
  81.  
  82.    collect_c_tmp is
  83.       do
  84.      right_side.collect_c_tmp;
  85.       end;
  86.  
  87.    compile_to_c is
  88.       local
  89.      left_run_type, right_run_type: TYPE;
  90.       do
  91.      if run_control.no_check then
  92.         cpp.se_trace_ins(start_position);
  93.      end;
  94.      left_run_type := left_type.run_type;
  95.      right_run_type := right_type.run_type;
  96.      if left_run_type.is_reference then
  97.         if right_run_type.is_reference then
  98.            -- ------------------------ Reference into Reference :
  99.            left_side.compile_to_c;
  100.            cpp.put_character('=');
  101.            if right_side.is_current then
  102.           cpp.put_string(fz_cast_t0_star);
  103.            end;
  104.            right_side.compile_to_c;
  105.            cpp.put_string(fz_00);
  106.         else
  107.            -- ------------------------- Expanded into Reference :
  108.            left_side.compile_to_c;
  109.            cpp.put_character('=');
  110.            right_run_type.to_reference;
  111.            cpp.put_character('(');
  112.            right_side.compile_to_c;
  113.            cpp.put_character(')');
  114.            cpp.put_string(fz_00);
  115.         end;
  116.      else
  117.         check
  118.            left_run_type.is_expanded
  119.         end;
  120.         if right_run_type.is_reference then
  121.            -- ------------------------- Reference into Expanded :
  122.            -- (std_copy or fail when Void).
  123.            eh.add_position(left_side.start_position);
  124.            fatal_error("Not Yet Implemented %
  125.                %(ASSIGNMENT/Reference into Expanded).");
  126.         else
  127.            -- -------------------------- Expanded into Expanded :
  128.            if left_run_type.is_bit then
  129.           bit_into_bit(left_run_type,right_run_type);
  130.            else
  131.           c_coding1;
  132.            end;
  133.         end;
  134.      end;
  135.       end;
  136.    
  137.    compile_to_jvm is
  138.       do
  139.      left_side.compile_to_jvm_assignment(Current);
  140.       end;
  141.    
  142.    use_current: BOOLEAN is
  143.       do
  144.      Result := left_side.use_current;
  145.      Result := Result or else right_side.use_current;
  146.       end;
  147.       
  148.    right_type: TYPE is
  149.       do
  150.      Result := right_side.result_type;
  151.       ensure
  152.      Result /= Void
  153.       end;
  154.    
  155.    left_type: TYPE is
  156.       do
  157.      Result := left_side.result_type;
  158.       ensure
  159.      Result /= Void
  160.       end;
  161.    
  162.    start_position: POSITION is
  163.       do
  164.      Result := left_side.start_position;
  165.       end;
  166.    
  167.    to_runnable(ct: TYPE): like Current is
  168.       local
  169.      l, r: EXPRESSION;
  170.       do
  171.      l := left_side.to_runnable(ct);
  172.      if l = Void then
  173.         eh.add_position(left_side.start_position);
  174.         fatal_error(fz_blhsoa);
  175.      end;
  176.      r := right_side.to_runnable(ct);
  177.      if r = Void then
  178.         eh.add_position(right_side.start_position);
  179.         fatal_error(fz_brhsoa);
  180.      end;
  181.      if not r.result_type.is_a(l.result_type) then
  182.         eh.add_position(l.start_position);
  183.         fatal_error(" Bad assignment.");
  184.      end;
  185.      if l = left_side and then r = right_side then
  186.         Result := Current;
  187.         implicit_conversion;
  188.      else
  189.         !!Result.make(l,r);
  190.         Result.implicit_conversion;
  191.      end;
  192.       end;
  193.    
  194.    pretty_print is
  195.       do
  196.      pretty_print_assignment(left_side,":=",right_side);
  197.       end;
  198.  
  199. feature {ASSIGNMENT}
  200.  
  201.    implicit_conversion is
  202.       local
  203.      left_run_type, right_run_type: TYPE;
  204.       do
  205.      if nb_errors = 0 then
  206.         left_run_type := left_type.run_type;
  207.         right_run_type := right_type.run_type;
  208.         if left_run_type.is_reference then
  209.            if right_run_type.is_reference then
  210.           -- ------------------------- Reference into Reference :
  211.            else
  212.           -- -------------------------- Expanded into Reference :
  213.           right_run_type.used_as_reference;
  214.            end;
  215.         else
  216.            if right_run_type.is_reference then
  217.           -- -------------------------- Reference into Expanded :
  218.           if right_side.is_void then
  219.              eh.add_position(right_side.start_position);
  220.              eh.append("Void may not be assigned to an %
  221.                    %expanded entity. Left hand side is ");
  222.              eh.add_type(left_type,".");
  223.              eh.print_as_error;
  224.           else
  225.              warning(left_side.start_position,
  226.                  "ASSIGNMENT/Not Yet Implemented.");
  227.           end;
  228.            else
  229.           -- --------------------------- Expanded into Expanded :
  230.            end;
  231.         end;
  232.      end;
  233.       end;
  234.  
  235. feature {NONE}
  236.  
  237.    c_coding1 is
  238.       do
  239.      left_side.compile_to_c;
  240.      cpp.put_character('=');
  241.      right_side.compile_to_c;
  242.      cpp.put_string(fz_00);
  243.       end;
  244.  
  245.    bit_into_bit(left_t, right_t: TYPE) is
  246.       require
  247.      left_t.is_bit;
  248.      right_t.is_bit
  249.       local 
  250.      left, right: TYPE_BIT;
  251.       do
  252.      left ?= left_t;
  253.      right ?= right_t;
  254.      if left.is_c_char then -- ------- unsigned char <- unsigned char :
  255.            c_coding1;
  256.      elseif left.is_c_int then 
  257.         -- ---------------------- unsigned int <- unsigned [char|int] :
  258.         c_coding1;
  259.      elseif right.is_c_unsigned_ptr then -- -- unsigned* <- unsigned* :
  260.         cpp.put_string("memcpy(");
  261.         left_side.mapping_c_arg(left);
  262.         cpp.put_character(',');
  263.         right_side.mapping_c_arg(right);
  264.         cpp.put_character(',');
  265.         cpp.put_integer(left.space_for_variable);
  266.         cpp.put_character(')');
  267.         cpp.put_string(fz_00);
  268.      else
  269.         cpp.put_string("memset(&"); 
  270.         left_side.compile_to_c;
  271.         cpp.put_string(",0,sizeof(");
  272.         left_side.compile_to_c;
  273.         cpp.put_string(fz_16);
  274.      end;
  275.       end;
  276.  
  277. invariant
  278.    
  279.    left_side.is_writable;
  280.    
  281.    right_side /= Void
  282.    
  283. end -- ASSIGNMENT
  284.  
  285.